package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.api.AlbumInfoApiController;
import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.BaseAttributeValueMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.cache.GuiGuCache;
import com.atguigu.tingshu.common.config.redis.RedissonConfig;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.BaseAttributeValue;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import nonapi.io.github.classgraph.json.Id;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;

	@Autowired
	private AlbumAttributeValueMapper albumAttributeValueMapper;

	@Autowired
	private AlbumStatMapper albumStatMapper;

	@Autowired
	private AlbumAttributeValueService albumAttributeValueService;

	@Autowired
	private BaseAttributeValueMapper baseAttributeValueMapper;

	@Autowired
	private RabbitService rabbitService;

	@Autowired
	private RedisTemplate redisTemplate;


	//新增专辑接口
	//考虑：1 添加专辑之后，获取专辑id，操作其他内容
	// 2  考虑事务   要成功一起成功，一个失败都失败
	@Override
	@Transactional
	public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
		//要往三个表中添加数据
		// album_info   album_attribute_value   album_stat
		// 1 向 album_info添加数据
		AlbumInfo albumInfo = new AlbumInfo();
		BeanUtils.copyProperties(albumInfoVo, albumInfo);
		albumInfo.setUserId(userId);
		//设置专辑审核状态为已通过  0301
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
		//如果不是免费的专辑，可以试听前五集
		if (!albumInfo.getPayType().equals(SystemConstant.ALBUM_PAY_TYPE_FREE)) {
			//表示不是0101——免费类型的专辑
			albumInfo.setTracksForFree(5);
		}
		albumInfoMapper.insert(albumInfo);


		// 2 album_attribute_value添加数据
		BaseAttributeValue baseAttributeValue = new BaseAttributeValue();
//		List<AlbumAttributeValue> albumAttributeValueVoList = albumInfo.getAlbumAttributeValueVoList();
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();

		//判断，集合不为空就遍历

		if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {
//			albumAttributeValueVoList.forEach(albumAttributeValueVo ->{
//				//AlbumAttributeValueVo -->   AlbumAttributeValue
//				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
//				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
//				albumAttributeValue.setAlbumId(albumInfo.getId());
//				albumAttributeValueMapper.insert(albumAttributeValue);
//			});
			//优化之批量添加
			List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueVoList.stream().map(albumAttributeValueVo -> {
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				return albumAttributeValue;
			}).collect(Collectors.toList());
			List<AlbumAttributeValue> list = albumAttributeValueList;
			albumAttributeValueService.saveBatch(list);
		}

		//album_stat 添加数据
		AlbumStat albumStat1 = new AlbumStat();
		albumStat1.setAlbumId(albumInfo.getId());
		//表示0401
		albumStat1.setStatType(SystemConstant.ALBUM_STAT_PLAY);
		albumStat1.setStatNum(0);
		albumStatMapper.insert(albumStat1);
		//----------------------------------
		AlbumStat albumStat2 = new AlbumStat();
		albumStat2.setAlbumId(albumInfo.getId());
		//表示0402
		albumStat2.setStatType(SystemConstant.ALBUM_STAT_SUBSCRIBE);
		albumStat2.setStatNum(0);
		albumStatMapper.insert(albumStat2);
		//------------------------------------
		AlbumStat albumStat3 = new AlbumStat();
		albumStat3.setAlbumId(albumInfo.getId());
		//表示0403
		albumStat3.setStatType(SystemConstant.ALBUM_STAT_BROWSE);
		albumStat3.setStatNum(0);
		albumStatMapper.insert(albumStat3);
		//------------------------------------
		AlbumStat albumStat4 = new AlbumStat();
		albumStat4.setAlbumId(albumInfo.getId());
		//表示0404
		albumStat4.setStatType(SystemConstant.ALBUM_STAT_COMMENT);
		albumStat4.setStatNum(0);
		albumStatMapper.insert(albumStat4);
		//------------------------------------

		//4 通过MQ实现专辑上架和下架
		//判断是否是私密，如果是，就不上架
		String isOpen = albumInfo.getIsOpen();
		//如果公开，就上架
		if("1".equals(isOpen)){
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,
					MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
		}

	}

	//获取当前用户专辑分页查询
	@Override
	public IPage<AlbumListVo> findUserAlbmPage(Page<AlbumListVo> albumListVoPage, AlbumInfoQuery albumInfoQuery) {
		return albumInfoMapper.findUserAlbmPageMapper(albumListVoPage, albumInfoQuery);
	}

	//修改专辑之根据id查询专辑

	@Autowired
	private RedissonClient redissonClient;
//	@Override

//	public AlbumInfo getAlbumInfoById(Long id) {
//		//专辑详情优化之添加缓存
//		//1 查询redis缓存
//		String key = RedisConstant.ALBUM_INFO_PREFIX+id;
//		AlbumInfo albumInfo = (AlbumInfo)redisTemplate.opsForValue().get(key);
//		if(albumInfo==null){
//			//说明redis中没有查询到
//			//2 如果redis查询不到数据 查询mysql 把mysql的数据放到redis中
//			//查询mysql添加分布式锁  使用redission实现
//		try{
//			//获取锁对象
//			String redissonkey = RedisConstant.ALBUM_INFO_PREFIX+id+"_lock";
//			RLock rLock = redissonClient.getLock(redissonkey);
//			//加锁
//			boolean lock = rLock.tryLock(10, 30, TimeUnit.SECONDS);
//			if (lock){
//				try {
//					//加锁成功
//					//查询mysql  把mysql中的数据放到redis中去
//					AlbumInfo albumInfoByIdData = this.getAlbumInfoByIdData(id);
//					if(albumInfoByIdData==null){
//						albumInfoByIdData = new AlbumInfo();
//						redisTemplate.opsForValue().set(key,albumInfoByIdData,RedisConstant.ALBUM_TIMEOUT,TimeUnit.SECONDS);
//
//					}
//					redisTemplate.opsForValue().set(key,albumInfoByIdData,RedisConstant.ALBUM_TIMEOUT,TimeUnit.SECONDS);
//					return albumInfoByIdData;
//
//				} finally {
//					//解锁
//					rLock.unlock();
//				}
//			}else{
//				//加锁失败 自旋
//				return  getAlbumInfoById(id);
//			}
//		} catch (InterruptedException e) {
//			throw new RuntimeException(e);
//		}
//		}else{
//			//3 如果redis查询数据  直接返回
//			return albumInfo;
//		}
//
//	}
	//修改专辑之根据id查询专辑
	private AlbumInfo getAlbumInfoByIdData(Long id) {
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		//获取专辑标签属性信息
		List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper
				.selectList(new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId, id));
		albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
		return albumInfo;
	}

	//修改专辑之根据id查询专辑
	@GuiGuCache(prefix = "album:info")
	@Override
	public AlbumInfo getAlbumInfoById(Long id) {
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		//获取专辑标签属性信息
		List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper
				.selectList(new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId, id));
		albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
		return albumInfo;
	}

	//修改专辑之根据id修改专辑信息
	@Override
	public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
		//1  修改album_info表中的基本信息
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		BeanUtils.copyProperties(albumInfoVo, albumInfo);
		albumInfoMapper.updateById(albumInfo);
		//2 修改album_attribute_value 表中的标签信息
		//需要先删除，再重新添加
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		//集合不为空就遍历
		if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {
			albumAttributeValueVoList.forEach(albumAttributeValueVo -> {
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
				albumAttributeValue.setAlbumId(id);
				albumAttributeValueMapper.insert(albumAttributeValue);
			});
		}

	}

	//获取当前用户全部专辑列表
	@Override
	public List<AlbumInfo> findUserAllAlbumList(Long userId) {
		//默认查看第一页
		Page<AlbumInfo> page = new Page<>(1, 100);
		LambdaQueryWrapper<AlbumInfo> wrapper = new LambdaQueryWrapper<AlbumInfo>().eq(AlbumInfo::getUserId, userId);
		wrapper.select(AlbumInfo::getId, AlbumInfo::getAlbumTitle);
		wrapper.orderByDesc(AlbumInfo::getId);
		Page<AlbumInfo> page1 = albumInfoMapper.selectPage(page, wrapper);
		List<AlbumInfo> albumInfoList = page1.getRecords();
		return albumInfoList;
	}


//	@Override
//	public IPage<AlbumListVo> findUserAlbmPage(Long page,Long limit, AlbumInfoQuery albumInfoQuery) {
//		Page<AlbumInfo> albumInfoPage = new Page<>(page, limit);
//		Page<AlbumInfo> albumInfoPage1 = albumInfoMapper.selectPage(albumInfoPage, null);
//		return albumInfoMapper.findUserAlbmPageMapper(albumInfoPage1,albumInfoQuery);
//	}


	//根据专辑id删除专辑
	//要删除三张表的数据   album_info  album_attribute_value album_stat
	//要有事务  要成功一起成功， 一个失败都失败
	@Override
	@Transactional
	public void removeAlbumInfo(Long id) {
		//0  判断专辑里是否有声音，若有声音则不能删除
		AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		Integer includeTrackCount = albumInfo.getIncludeTrackCount();
		System.out.println(includeTrackCount);
		if (includeTrackCount != 0) {
			//表示专辑里还有声音，不能删除
			throw new GuiguException(400, "该专辑存在声音，不能删除！！");
		}
		System.out.println(id);
		//1  删除album_info的数据
		albumInfoMapper.deleteById(id);
		// 2  删除album_attribute_value的数据
		albumAttributeValueMapper.delete(
				new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId, id));

		//3  删除album_stat的数据
		albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>()
				.eq(AlbumStat::getAlbumId, id));

		//4专辑下架  MQ实现
		rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER
				,id);
	}

	//获取专辑属性值信息
	@Override
	public List<AlbumAttributeValue> findAlbumAttributeValue(Long id) {
		LambdaQueryWrapper<AlbumAttributeValue> wrapper = new LambdaQueryWrapper<>();
		wrapper.eq(AlbumAttributeValue::getAlbumId, id);
		List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(wrapper);
//
//		List<BaseAttributeValue> baseAttributeValueList = albumAttributeValueList.stream().map(albumAttributeValue -> {
//			Long attributeId = albumAttributeValue.getAttributeId();
//			List<BaseAttributeValue> valueList = baseAttributeValueMapper.selectList(new LambdaQueryWrapper<BaseAttributeValue>().eq(BaseAttributeValue::getAttributeId,attributeId));
//			return valueList;
//		}).collect(Collectors.toList());
		//新建一个集合
//		ArrayList<BaseAttributeValue> baseAttributeValues = new ArrayList<>();
//		for (AlbumAttributeValue albumAttributeValue : albumAttributeValueList) {
//			Long attributeId = albumAttributeValue.getAttributeId();
//			List<BaseAttributeValue> valueList = baseAttributeValueMapper.selectList(new LambdaQueryWrapper<BaseAttributeValue>().eq(BaseAttributeValue::getAttributeId,attributeId));
//			baseAttributeValues.addAll(valueList);
//		}

		return albumAttributeValueList;
	}

	//根据专辑id获取四个统计数据
	@Override
	public Map<String, Object> getAlbumStat(Long albumId) {

		return albumStatMapper.getAlbumStatMapper(albumId);
	}

	//根据专辑id获取统计数据
	@Override
	public AlbumStatVo getAlbumStatVo(Long albumId) {

	AlbumStatVo albumStatVo = albumStatMapper.getAlbumStatVoMapper(albumId);
		return albumStatVo;
	}
}
